Line data Source code
1 : /* SPDX-License-Identifier: MIT OR GPL-3.0-only */
2 : /* tls_openssl.c
3 : ** strophe XMPP client library -- TLS abstraction openssl impl.
4 : **
5 : ** Copyright (C) 2005-008 Collecta, Inc.
6 : **
7 : ** This software is provided AS-IS with no warranty, either express
8 : ** or implied.
9 : **
10 : ** This program is dual licensed under the MIT or GPLv3 licenses.
11 : */
12 :
13 : /** @file
14 : * TLS implementation with OpenSSL.
15 : */
16 :
17 : #include <errno.h> /* EINTR */
18 : #include <string.h>
19 :
20 : #ifndef _WIN32
21 : #include <sys/select.h>
22 : #else
23 : #include <winsock2.h>
24 : #endif
25 :
26 : #include <openssl/ssl.h>
27 : #include <openssl/err.h>
28 : #include <openssl/opensslv.h>
29 : #include <openssl/x509v3.h>
30 : #include <openssl/pkcs12.h>
31 :
32 : #include "common.h"
33 : #include "tls.h"
34 : #include "sock.h"
35 :
36 : /*
37 : * Redefine OPENSSL_VERSION_NUMBER for LibreSSL.
38 : * LibreSSL and OpenSSL use different and incompatible version schemes. Solve
39 : * this issue in the way how nginx project did.
40 : */
41 : #if (defined LIBRESSL_VERSION_NUMBER && OPENSSL_VERSION_NUMBER == 0x20000000L)
42 : #undef OPENSSL_VERSION_NUMBER
43 : #if (LIBRESSL_VERSION_NUMBER >= 0x2080000fL)
44 : #define OPENSSL_VERSION_NUMBER 0x1010000fL
45 : #elif (LIBRESSL_VERSION_NUMBER >= 0x2070000fL)
46 : #define OPENSSL_VERSION_NUMBER 0x1000200fL
47 : #else
48 : #define OPENSSL_VERSION_NUMBER 0x1000107fL
49 : #endif
50 : #endif
51 :
52 : #if OPENSSL_VERSION_NUMBER < 0x30000000L
53 : #define STROPHE_ERR_func_error_string(e) ERR_func_error_string(e)
54 : #define STROPHE_SSL_get1_peer_certificate(s) SSL_get_peer_certificate(s)
55 : #else
56 : #define STROPHE_ERR_func_error_string(e) ""
57 : #define STROPHE_SSL_get1_peer_certificate(s) SSL_get1_peer_certificate(s)
58 : #endif
59 :
60 : #if OPENSSL_VERSION_NUMBER < 0x10100000L
61 : static const unsigned char *ASN1_STRING_get0_data(ASN1_STRING *asn1)
62 : {
63 : return ASN1_STRING_data(asn1);
64 : }
65 : #endif
66 :
67 : #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined LIBRESSL_VERSION_NUMBER
68 : static int SSL_CTX_use_cert_and_key(SSL_CTX *ctx,
69 : X509 *x509,
70 : EVP_PKEY *privatekey,
71 : STACK_OF(X509) * chain,
72 : int override)
73 : {
74 : UNUSED(override);
75 : if (!ctx)
76 : return 0;
77 : if (x509 && !SSL_CTX_use_certificate(ctx, x509))
78 : return 0;
79 : if (privatekey && !SSL_CTX_use_PrivateKey(ctx, privatekey))
80 : return 0;
81 : #ifdef SSL_CTX_set1_chain
82 : if (chain && !SSL_CTX_set1_chain(ctx, chain))
83 : return 0;
84 : #else
85 : UNUSED(chain);
86 : #endif
87 : return 1;
88 : }
89 : #endif
90 :
91 : #if OPENSSL_VERSION_NUMBER < 0x10000000L
92 : static int GENERAL_NAME_get0_otherName(const GENERAL_NAME *gen,
93 : ASN1_OBJECT **poid,
94 : ASN1_TYPE **pvalue)
95 : {
96 : if (gen->type != GEN_OTHERNAME)
97 : return 0;
98 : if (poid)
99 : *poid = gen->d.otherName->type_id;
100 : if (pvalue)
101 : *pvalue = gen->d.otherName->value;
102 : return 1;
103 : }
104 : #endif
105 :
106 : struct _tls {
107 : xmpp_ctx_t *ctx;
108 : sock_t sock;
109 : SSL_CTX *ssl_ctx;
110 : SSL *ssl;
111 : X509 *client_cert;
112 : void *channel_binding_data;
113 : size_t channel_binding_size;
114 : FILE *keylogfile;
115 : int lasterror;
116 : };
117 :
118 : enum {
119 : TLS_SHUTDOWN_MAX_RETRIES = 10,
120 : TLS_TIMEOUT_SEC = 0,
121 : TLS_TIMEOUT_USEC = 100000,
122 : };
123 :
124 : static void _tls_sock_wait(tls_t *tls, int error);
125 : static const char *_tls_error_str(int error, const char **tbl, size_t tbl_size);
126 : static void _tls_set_error(tls_t *tls, int error);
127 : static void _tls_log_error(xmpp_ctx_t *ctx);
128 : static void _tls_dump_cert_info(tls_t *tls);
129 : static X509 *_tls_cert_read(xmpp_conn_t *conn);
130 : static X509 *
131 : _tls_cert_read_p12(xmpp_conn_t *conn, EVP_PKEY **pkey, STACK_OF(X509) * *ca);
132 : static int _tls_xaddr_nid(void);
133 : static int _tls_xmppaddr_to_string(GENERAL_NAME *name, char **res);
134 : static int _tls_dnsname_to_string(GENERAL_NAME *name, char **res);
135 : static GENERAL_NAMES *_tls_conn_get_names(xmpp_conn_t *conn);
136 : static GENERAL_NAMES *_tls_cert_get_names(X509 *client_cert);
137 :
138 : #define TLS_ERROR_STR(error, table) \
139 : _tls_error_str(error, table, ARRAY_SIZE(table))
140 :
141 : #define TLS_ERROR_FIELD(x) [x] = #x
142 : const char *tls_errors[] = {
143 : TLS_ERROR_FIELD(SSL_ERROR_NONE),
144 : TLS_ERROR_FIELD(SSL_ERROR_SSL),
145 : TLS_ERROR_FIELD(SSL_ERROR_WANT_READ),
146 : TLS_ERROR_FIELD(SSL_ERROR_WANT_WRITE),
147 : TLS_ERROR_FIELD(SSL_ERROR_WANT_X509_LOOKUP),
148 : TLS_ERROR_FIELD(SSL_ERROR_SYSCALL),
149 : TLS_ERROR_FIELD(SSL_ERROR_ZERO_RETURN),
150 : TLS_ERROR_FIELD(SSL_ERROR_WANT_CONNECT),
151 : TLS_ERROR_FIELD(SSL_ERROR_WANT_ACCEPT),
152 : #ifndef LIBRESSL_VERSION_NUMBER
153 : #if OPENSSL_VERSION_NUMBER >= 0x10100000L
154 : TLS_ERROR_FIELD(SSL_ERROR_WANT_ASYNC),
155 : TLS_ERROR_FIELD(SSL_ERROR_WANT_ASYNC_JOB),
156 : #endif
157 : #if OPENSSL_VERSION_NUMBER >= 0x10101000L
158 : TLS_ERROR_FIELD(SSL_ERROR_WANT_CLIENT_HELLO_CB),
159 : #endif
160 : #endif /* !LIBRESSL_VERSION_NUMBER */
161 : };
162 : const char *cert_errors[] = {
163 : TLS_ERROR_FIELD(X509_V_OK),
164 : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
165 : TLS_ERROR_FIELD(X509_V_ERR_UNSPECIFIED),
166 : #endif
167 : TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT),
168 : TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_CRL),
169 : TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE),
170 : TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE),
171 : TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY),
172 : TLS_ERROR_FIELD(X509_V_ERR_CERT_SIGNATURE_FAILURE),
173 : TLS_ERROR_FIELD(X509_V_ERR_CRL_SIGNATURE_FAILURE),
174 : TLS_ERROR_FIELD(X509_V_ERR_CERT_NOT_YET_VALID),
175 : TLS_ERROR_FIELD(X509_V_ERR_CERT_HAS_EXPIRED),
176 : TLS_ERROR_FIELD(X509_V_ERR_CRL_NOT_YET_VALID),
177 : TLS_ERROR_FIELD(X509_V_ERR_CRL_HAS_EXPIRED),
178 : TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD),
179 : TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD),
180 : TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD),
181 : TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD),
182 : TLS_ERROR_FIELD(X509_V_ERR_OUT_OF_MEM),
183 : TLS_ERROR_FIELD(X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT),
184 : TLS_ERROR_FIELD(X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN),
185 : TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY),
186 : TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE),
187 : TLS_ERROR_FIELD(X509_V_ERR_CERT_CHAIN_TOO_LONG),
188 : TLS_ERROR_FIELD(X509_V_ERR_CERT_REVOKED),
189 : TLS_ERROR_FIELD(X509_V_ERR_INVALID_CA),
190 : TLS_ERROR_FIELD(X509_V_ERR_PATH_LENGTH_EXCEEDED),
191 : TLS_ERROR_FIELD(X509_V_ERR_INVALID_PURPOSE),
192 : TLS_ERROR_FIELD(X509_V_ERR_CERT_UNTRUSTED),
193 : TLS_ERROR_FIELD(X509_V_ERR_CERT_REJECTED),
194 : TLS_ERROR_FIELD(X509_V_ERR_SUBJECT_ISSUER_MISMATCH),
195 : TLS_ERROR_FIELD(X509_V_ERR_AKID_SKID_MISMATCH),
196 : TLS_ERROR_FIELD(X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH),
197 : TLS_ERROR_FIELD(X509_V_ERR_KEYUSAGE_NO_CERTSIGN),
198 : TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER),
199 : TLS_ERROR_FIELD(X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION),
200 : TLS_ERROR_FIELD(X509_V_ERR_KEYUSAGE_NO_CRL_SIGN),
201 : TLS_ERROR_FIELD(X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION),
202 : TLS_ERROR_FIELD(X509_V_ERR_INVALID_NON_CA),
203 : TLS_ERROR_FIELD(X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED),
204 : TLS_ERROR_FIELD(X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE),
205 : TLS_ERROR_FIELD(X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED),
206 : TLS_ERROR_FIELD(X509_V_ERR_INVALID_EXTENSION),
207 : TLS_ERROR_FIELD(X509_V_ERR_INVALID_POLICY_EXTENSION),
208 : TLS_ERROR_FIELD(X509_V_ERR_NO_EXPLICIT_POLICY),
209 : TLS_ERROR_FIELD(X509_V_ERR_APPLICATION_VERIFICATION),
210 : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
211 : TLS_ERROR_FIELD(X509_V_ERR_DIFFERENT_CRL_SCOPE),
212 : TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE),
213 : TLS_ERROR_FIELD(X509_V_ERR_UNNESTED_RESOURCE),
214 : TLS_ERROR_FIELD(X509_V_ERR_PERMITTED_VIOLATION),
215 : TLS_ERROR_FIELD(X509_V_ERR_EXCLUDED_VIOLATION),
216 : TLS_ERROR_FIELD(X509_V_ERR_SUBTREE_MINMAX),
217 : TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE),
218 : TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX),
219 : TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_NAME_SYNTAX),
220 : TLS_ERROR_FIELD(X509_V_ERR_CRL_PATH_VALIDATION_ERROR),
221 : #ifndef LIBRESSL_VERSION_NUMBER
222 : TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_VERSION),
223 : TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_ALGORITHM),
224 : TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_CURVE),
225 : TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM),
226 : TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED),
227 : TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256),
228 : #endif /* !LIBRESSL_VERSION_NUMBER */
229 : TLS_ERROR_FIELD(X509_V_ERR_HOSTNAME_MISMATCH),
230 : TLS_ERROR_FIELD(X509_V_ERR_EMAIL_MISMATCH),
231 : TLS_ERROR_FIELD(X509_V_ERR_IP_ADDRESS_MISMATCH),
232 : #endif /* OPENSSL_VERSION_NUMBER >= 0x10002000L */
233 : #if OPENSSL_VERSION_NUMBER >= 0x10100000L
234 : TLS_ERROR_FIELD(X509_V_ERR_INVALID_CALL),
235 : TLS_ERROR_FIELD(X509_V_ERR_STORE_LOOKUP),
236 : #ifndef LIBRESSL_VERSION_NUMBER
237 : TLS_ERROR_FIELD(X509_V_ERR_PATH_LOOP),
238 : TLS_ERROR_FIELD(X509_V_ERR_DANE_NO_MATCH),
239 : TLS_ERROR_FIELD(X509_V_ERR_EE_KEY_TOO_SMALL),
240 : TLS_ERROR_FIELD(X509_V_ERR_CA_KEY_TOO_SMALL),
241 : TLS_ERROR_FIELD(X509_V_ERR_CA_MD_TOO_WEAK),
242 : TLS_ERROR_FIELD(X509_V_ERR_NO_VALID_SCTS),
243 : TLS_ERROR_FIELD(X509_V_ERR_PROXY_SUBJECT_NAME_VIOLATION),
244 : #if OPENSSL_VERSION_NUMBER >= 0x10101000L
245 : TLS_ERROR_FIELD(X509_V_ERR_OCSP_VERIFY_NEEDED),
246 : TLS_ERROR_FIELD(X509_V_ERR_OCSP_VERIFY_FAILED),
247 : TLS_ERROR_FIELD(X509_V_ERR_OCSP_CERT_UNKNOWN),
248 : #endif /* OPENSSL_VERSION_NUMBER >= 0x10101000L */
249 : #endif /* !LIBRESSL_VERSION_NUMBER */
250 : #endif /* OPENSSL_VERSION_NUMBER >= 0x10100000L */
251 : };
252 : #undef TLS_ERROR_FIELD
253 :
254 2 : void tls_initialize(void)
255 : {
256 : #if OPENSSL_VERSION_NUMBER < 0x10100000L
257 : SSL_library_init();
258 : SSL_load_error_strings();
259 : #else
260 2 : OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL);
261 : #endif
262 : /* init xmppAddr OID */
263 2 : _tls_xaddr_nid();
264 2 : }
265 :
266 2 : void tls_shutdown(void)
267 : {
268 : /*
269 : * FIXME: Don't free global tables, program or other libraries may use
270 : * openssl after libstrophe finalization. Maybe better leak some fixed
271 : * memory rather than cause random crashes of the main program.
272 : */
273 : #if OPENSSL_VERSION_NUMBER < 0x10100000L
274 : OBJ_cleanup();
275 : ERR_free_strings();
276 : EVP_cleanup();
277 : CRYPTO_cleanup_all_ex_data();
278 : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
279 : SSL_COMP_free_compression_methods();
280 : #endif
281 : #if OPENSSL_VERSION_NUMBER < 0x10000000L
282 : ERR_remove_state(0);
283 : #else
284 : ERR_remove_thread_state(NULL);
285 : #endif
286 : #endif
287 2 : }
288 :
289 0 : int tls_error(struct conn_interface *intf)
290 : {
291 0 : return intf->conn->tls->lasterror;
292 : }
293 :
294 : /** Search through the SubjectAlternativeNames and return the next
295 : * id-on-xmppAddr element starting from `n`.
296 : */
297 24 : char *tls_id_on_xmppaddr(xmpp_conn_t *conn, unsigned int n)
298 : {
299 24 : char *ret = NULL;
300 24 : int i, j;
301 24 : GENERAL_NAMES *names = _tls_conn_get_names(conn);
302 24 : if (!names) {
303 0 : _tls_log_error(conn->ctx);
304 0 : return NULL;
305 : }
306 24 : int num_names = sk_GENERAL_NAME_num(names);
307 104 : for (i = j = 0; i < num_names; ++i) {
308 72 : char *res;
309 72 : GENERAL_NAME *name = sk_GENERAL_NAME_value(names, i);
310 72 : if (name == NULL)
311 : break;
312 72 : if (_tls_xmppaddr_to_string(name, &res))
313 32 : continue;
314 40 : if (j == (int)n) {
315 16 : strophe_debug(conn->ctx, "tls",
316 : "extracted jid %s from id-on-xmppAddr", res);
317 16 : ret = strophe_strdup(conn->ctx, res);
318 16 : OPENSSL_free(res);
319 : break;
320 : }
321 24 : j++;
322 24 : OPENSSL_free(res);
323 : }
324 24 : GENERAL_NAMES_free(names);
325 24 : return ret;
326 : }
327 :
328 8 : unsigned int tls_id_on_xmppaddr_num(xmpp_conn_t *conn)
329 : {
330 8 : unsigned int ret = 0;
331 8 : GENERAL_NAMES *names = _tls_conn_get_names(conn);
332 8 : if (!names) {
333 0 : _tls_log_error(conn->ctx);
334 0 : return 0;
335 : }
336 8 : int j, num_names = sk_GENERAL_NAME_num(names);
337 48 : for (j = 0; j < num_names; ++j) {
338 32 : GENERAL_NAME *name = sk_GENERAL_NAME_value(names, j);
339 32 : if (_tls_xmppaddr_to_string(name, NULL))
340 16 : continue;
341 16 : ret++;
342 : }
343 8 : GENERAL_NAMES_free(names);
344 8 : return ret;
345 : }
346 :
347 0 : static int _convert_ASN1TIME(ASN1_TIME *ansi_time, char *buf, size_t len)
348 : {
349 0 : BIO *bio = BIO_new(BIO_s_mem());
350 0 : int rc = ASN1_TIME_print(bio, ansi_time);
351 0 : if (rc <= 0) {
352 0 : BIO_free(bio);
353 0 : return 0;
354 : }
355 0 : rc = BIO_gets(bio, buf, len);
356 0 : if (rc <= 0) {
357 0 : BIO_free(bio);
358 0 : return 0;
359 : }
360 0 : BIO_free(bio);
361 0 : return 1;
362 : }
363 :
364 0 : static char *_asn1_time_to_str(const xmpp_ctx_t *ctx, ASN1_TIME *t)
365 : {
366 0 : char buf[128];
367 0 : int res = _convert_ASN1TIME(t, buf, sizeof(buf));
368 0 : if (res) {
369 0 : return strophe_strdup(ctx, buf);
370 : }
371 : return NULL;
372 : }
373 :
374 : static char *
375 0 : _get_fingerprint(const xmpp_ctx_t *ctx, X509 *err_cert, xmpp_cert_element_t el)
376 : {
377 0 : unsigned char buf[EVP_MAX_MD_SIZE];
378 0 : unsigned int len;
379 0 : const EVP_MD *digest;
380 0 : switch (el) {
381 0 : case XMPP_CERT_FINGERPRINT_SHA1:
382 0 : digest = EVP_sha1();
383 : break;
384 0 : case XMPP_CERT_FINGERPRINT_SHA256:
385 0 : digest = EVP_sha256();
386 : break;
387 : default:
388 0 : return NULL;
389 : }
390 0 : if (X509_digest(err_cert, digest, buf, &len) != 0) {
391 0 : char fingerprint[4 * EVP_MAX_MD_SIZE];
392 0 : hex_encode(fingerprint, buf, len);
393 0 : return strophe_strdup(ctx, fingerprint);
394 : }
395 : return NULL;
396 : }
397 :
398 : static char *
399 0 : _get_alg(const xmpp_ctx_t *ctx, X509 *err_cert, xmpp_cert_element_t el)
400 : {
401 0 : int alg_nid = NID_undef;
402 :
403 0 : switch (el) {
404 0 : case XMPP_CERT_KEYALG: {
405 : #if OPENSSL_VERSION_NUMBER < 0x10100000L
406 : alg_nid = OBJ_obj2nid(err_cert->cert_info->key->algor->algorithm);
407 : #else
408 0 : X509_PUBKEY *pubkey = X509_get_X509_PUBKEY(err_cert);
409 0 : ASN1_OBJECT *ppkalg = NULL;
410 0 : if (X509_PUBKEY_get0_param(&ppkalg, NULL, NULL, NULL, pubkey)) {
411 0 : alg_nid = OBJ_obj2nid(ppkalg);
412 : }
413 : #endif
414 0 : } break;
415 0 : case XMPP_CERT_SIGALG: {
416 : #if OPENSSL_VERSION_NUMBER < 0x10100000L
417 : alg_nid = OBJ_obj2nid(err_cert->sig_alg->algorithm);
418 : #else
419 0 : const X509_ALGOR *palg;
420 0 : const ASN1_OBJECT *obj;
421 0 : X509_get0_signature(NULL, &palg, err_cert);
422 0 : X509_ALGOR_get0(&obj, NULL, NULL, palg);
423 0 : alg_nid = OBJ_obj2nid(obj);
424 : #endif
425 0 : } break;
426 : default:
427 : break;
428 : }
429 0 : if (alg_nid != NID_undef) {
430 0 : const char *alg = OBJ_nid2ln(alg_nid);
431 0 : if (alg) {
432 0 : return strophe_strdup(ctx, alg);
433 : }
434 : }
435 : return NULL;
436 : }
437 :
438 0 : static xmpp_tlscert_t *_x509_to_tlscert(xmpp_ctx_t *ctx, X509 *cert)
439 : {
440 0 : char *subject, *issuer, buf[32];
441 0 : xmpp_tlscert_t *tlscert = tlscert_new(ctx);
442 0 : if (!tlscert)
443 0 : return NULL;
444 :
445 0 : BIO *b = BIO_new(BIO_s_mem());
446 0 : if (!b)
447 0 : goto error_out;
448 0 : PEM_write_bio_X509(b, cert);
449 0 : BUF_MEM *bptr;
450 0 : BIO_get_mem_ptr(b, &bptr);
451 0 : tlscert->pem = strophe_alloc(ctx, bptr->length + 1);
452 0 : if (!tlscert->pem)
453 0 : goto error_out;
454 0 : memcpy(tlscert->pem, bptr->data, bptr->length);
455 0 : tlscert->pem[bptr->length] = '\0';
456 0 : BIO_free(b);
457 :
458 0 : subject = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0);
459 0 : if (!subject)
460 0 : goto error_out;
461 0 : tlscert->elements[XMPP_CERT_SUBJECT] = strophe_strdup(ctx, subject);
462 0 : OPENSSL_free(subject);
463 0 : issuer = X509_NAME_oneline(X509_get_issuer_name(cert), NULL, 0);
464 0 : if (!issuer)
465 0 : goto error_out;
466 0 : tlscert->elements[XMPP_CERT_ISSUER] = strophe_strdup(ctx, issuer);
467 0 : OPENSSL_free(issuer);
468 :
469 0 : tlscert->elements[XMPP_CERT_NOTBEFORE] =
470 0 : _asn1_time_to_str(ctx, X509_get_notBefore(cert));
471 0 : tlscert->elements[XMPP_CERT_NOTAFTER] =
472 0 : _asn1_time_to_str(ctx, X509_get_notAfter(cert));
473 :
474 0 : tlscert->elements[XMPP_CERT_FINGERPRINT_SHA1] =
475 0 : _get_fingerprint(ctx, cert, XMPP_CERT_FINGERPRINT_SHA1);
476 0 : tlscert->elements[XMPP_CERT_FINGERPRINT_SHA256] =
477 0 : _get_fingerprint(ctx, cert, XMPP_CERT_FINGERPRINT_SHA256);
478 :
479 0 : strophe_snprintf(buf, sizeof(buf), "%ld", X509_get_version(cert) + 1);
480 0 : tlscert->elements[XMPP_CERT_VERSION] = strophe_strdup(ctx, buf);
481 :
482 0 : tlscert->elements[XMPP_CERT_KEYALG] = _get_alg(ctx, cert, XMPP_CERT_KEYALG);
483 0 : tlscert->elements[XMPP_CERT_SIGALG] = _get_alg(ctx, cert, XMPP_CERT_SIGALG);
484 :
485 0 : ASN1_INTEGER *serial = X509_get_serialNumber(cert);
486 0 : BIGNUM *bn = ASN1_INTEGER_to_BN(serial, NULL);
487 0 : if (bn) {
488 0 : char *serialnumber = BN_bn2hex(bn);
489 0 : if (serialnumber) {
490 0 : tlscert->elements[XMPP_CERT_SERIALNUMBER] =
491 0 : strophe_strdup(ctx, serialnumber);
492 0 : OPENSSL_free(serialnumber);
493 : }
494 0 : BN_free(bn);
495 : }
496 :
497 0 : GENERAL_NAMES *names = _tls_cert_get_names(cert);
498 0 : if (names) {
499 0 : int j, num_names = sk_GENERAL_NAME_num(names);
500 : size_t n = 0;
501 0 : for (j = 0; j < num_names; ++j) {
502 0 : char *res;
503 0 : GENERAL_NAME *name = sk_GENERAL_NAME_value(names, j);
504 0 : if (_tls_dnsname_to_string(name, &res))
505 0 : continue;
506 0 : if (tlscert_add_dnsname(tlscert, res))
507 0 : strophe_debug(ctx, "tls", "Can't store dnsName(%zu): %s", n,
508 : res);
509 0 : n++;
510 0 : OPENSSL_free(res);
511 : }
512 0 : GENERAL_NAMES_free(names);
513 : }
514 :
515 : return tlscert;
516 0 : error_out:
517 0 : xmpp_tlscert_free(tlscert);
518 : return NULL;
519 : }
520 :
521 0 : static int _tls_verify(int preverify_ok, X509_STORE_CTX *x509_ctx)
522 : {
523 0 : if (preverify_ok == 1)
524 : return 1;
525 :
526 0 : SSL *ssl = X509_STORE_CTX_get_ex_data(x509_ctx,
527 : SSL_get_ex_data_X509_STORE_CTX_idx());
528 0 : xmpp_conn_t *conn = SSL_get_app_data(ssl);
529 :
530 0 : if (!conn->certfail_handler) {
531 0 : strophe_error(conn->ctx, "tls",
532 : "No certfail handler set, canceling connection attempt");
533 0 : return 0;
534 : }
535 :
536 0 : X509 *err_cert = X509_STORE_CTX_get_current_cert(x509_ctx);
537 :
538 0 : xmpp_tlscert_t *tlscert = _x509_to_tlscert(conn->ctx, err_cert);
539 :
540 0 : if (!tlscert)
541 : return 0;
542 :
543 0 : strophe_debug(conn->ctx, "tls", "preverify_ok:%d\nSubject: %s\nIssuer: %s",
544 : preverify_ok, tlscert->elements[XMPP_CERT_SUBJECT],
545 : tlscert->elements[XMPP_CERT_ISSUER]);
546 :
547 0 : int ret = conn->certfail_handler(
548 : tlscert,
549 0 : X509_verify_cert_error_string(X509_STORE_CTX_get_error(x509_ctx)));
550 :
551 0 : xmpp_tlscert_free(tlscert);
552 :
553 0 : return ret;
554 : }
555 :
556 8 : static int _tls_password_callback(char *buf, int size, int rwflag, void *u)
557 : {
558 8 : UNUSED(rwflag);
559 8 : return tls_caching_password_callback(buf, size, u);
560 : }
561 :
562 : #if OPENSSL_VERSION_NUMBER >= 0x10101000L
563 0 : static void _keylog_cb(const SSL *ssl, const char *line)
564 : {
565 0 : xmpp_conn_t *conn = SSL_get_app_data(ssl);
566 0 : fwrite(line, strlen(line), 1, conn->tls->keylogfile);
567 0 : fputc('\n', conn->tls->keylogfile);
568 0 : fflush(conn->tls->keylogfile);
569 0 : }
570 : #endif
571 :
572 0 : static void _try_open_keylogfile(tls_t *tls)
573 : {
574 : #if OPENSSL_VERSION_NUMBER >= 0x10101000L
575 0 : const char *first_line = "# SSL Key logfile generated by libstrophe\n";
576 0 : const char *SSLKEYLOGFILE = getenv("SSLKEYLOGFILE");
577 0 : if (!SSLKEYLOGFILE || *SSLKEYLOGFILE == '\0')
578 : return;
579 0 : tls->keylogfile = fopen(SSLKEYLOGFILE, "abe");
580 0 : if (!tls->keylogfile) {
581 0 : strophe_warn(tls->ctx, "tls", "Could not open SSL keylog file %s",
582 : SSLKEYLOGFILE);
583 0 : return;
584 : }
585 0 : fwrite(first_line, strlen(first_line), 1, tls->keylogfile);
586 0 : SSL_CTX_set_keylog_callback(tls->ssl_ctx, _keylog_cb);
587 : #else
588 : UNUSED(tls);
589 : #endif
590 : }
591 :
592 0 : tls_t *tls_new(xmpp_conn_t *conn)
593 : {
594 0 : tls_t *tls = strophe_alloc(conn->ctx, sizeof(*tls));
595 :
596 0 : if (tls) {
597 0 : int ret;
598 : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
599 : /* Hostname verification is supported in OpenSSL 1.0.2 and newer. */
600 0 : X509_VERIFY_PARAM *param;
601 : #endif
602 0 : memset(tls, 0, sizeof(*tls));
603 :
604 0 : tls->ctx = conn->ctx;
605 0 : tls->sock = conn->sock;
606 : #if OPENSSL_VERSION_NUMBER < 0x10100000L
607 : tls->ssl_ctx = SSL_CTX_new(SSLv23_client_method());
608 : #else
609 0 : tls->ssl_ctx = SSL_CTX_new(TLS_client_method());
610 : #endif
611 0 : if (tls->ssl_ctx == NULL)
612 0 : goto err;
613 :
614 : /* Enable bug workarounds. */
615 0 : SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_ALL);
616 :
617 : /* Disable insecure SSL/TLS versions. */
618 0 : SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_NO_SSLv2); /* DROWN */
619 0 : SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_NO_SSLv3); /* POODLE */
620 0 : SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_NO_TLSv1); /* BEAST */
621 :
622 0 : if (conn->password_callback) {
623 0 : SSL_CTX_set_default_passwd_cb(tls->ssl_ctx, _tls_password_callback);
624 0 : SSL_CTX_set_default_passwd_cb_userdata(tls->ssl_ctx, conn);
625 : }
626 :
627 0 : if (conn->tls_client_cert && conn->tls_client_key) {
628 0 : unsigned int retries = 0;
629 0 : tls->client_cert = _tls_cert_read(conn);
630 0 : if (!tls->client_cert) {
631 0 : strophe_error(tls->ctx, "tls",
632 : "could not read client certificate");
633 0 : goto err_free_ctx;
634 : }
635 :
636 0 : SSL_CTX_use_certificate_file(tls->ssl_ctx, conn->tls_client_cert,
637 : SSL_FILETYPE_PEM);
638 0 : while (retries++ < conn->password_retries) {
639 0 : if (SSL_CTX_use_PrivateKey_file(
640 0 : tls->ssl_ctx, conn->tls_client_key, SSL_FILETYPE_PEM)) {
641 : break;
642 : }
643 0 : tls_clear_password_cache(conn);
644 0 : unsigned long err = ERR_peek_error();
645 0 : if ((ERR_GET_LIB(err) == ERR_LIB_EVP &&
646 0 : ERR_GET_REASON(err) == EVP_R_BAD_DECRYPT) ||
647 0 : (ERR_GET_LIB(err) == ERR_LIB_PEM &&
648 0 : ERR_GET_REASON(err) == PEM_R_BAD_DECRYPT)) {
649 0 : strophe_debug(tls->ctx, "tls", "wrong password?");
650 0 : continue;
651 : }
652 0 : strophe_error(tls->ctx, "tls",
653 : "could not use private key %d %d",
654 : ERR_GET_LIB(err), ERR_GET_REASON(err));
655 0 : goto err_free_ctx;
656 : }
657 0 : } else if (conn->tls_client_cert) {
658 0 : EVP_PKEY *pkey = NULL;
659 0 : STACK_OF(X509) *ca = NULL;
660 0 : X509 *cert = _tls_cert_read_p12(conn, &pkey, &ca);
661 0 : if (!cert) {
662 0 : goto err_free_ctx;
663 : }
664 :
665 0 : SSL_CTX_use_cert_and_key(tls->ssl_ctx, cert, pkey, ca, 1);
666 :
667 0 : if (pkey)
668 0 : EVP_PKEY_free(pkey);
669 0 : if (ca)
670 0 : sk_X509_pop_free(ca, X509_free);
671 0 : tls->client_cert = cert;
672 : } else {
673 : /* If the server asks for a client certificate, don't send one. */
674 0 : SSL_CTX_set_client_cert_cb(tls->ssl_ctx, NULL);
675 : }
676 :
677 0 : SSL_CTX_set_mode(tls->ssl_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
678 :
679 0 : ret = SSL_CTX_set_default_verify_paths(tls->ssl_ctx);
680 0 : if (ret == 0 && !conn->tls_trust) {
681 : /*
682 : * Returns 1 on success and 0 on failure. A missing default
683 : * location is still treated as a success.
684 : * Ignore errors when XMPP_CONN_FLAG_TRUST_TLS is set.
685 : */
686 0 : strophe_error(tls->ctx, "tls",
687 : "SSL_CTX_set_default_verify_paths() failed");
688 0 : goto err_free_cert;
689 : }
690 :
691 0 : if (conn->tls_cafile || conn->tls_capath) {
692 0 : if (SSL_CTX_load_verify_locations(tls->ssl_ctx, conn->tls_cafile,
693 0 : conn->tls_capath) == 0) {
694 0 : strophe_error(tls->ctx, "tls",
695 : "SSL_CTX_load_verify_locations() failed");
696 0 : goto err_free_cert;
697 : }
698 : }
699 :
700 0 : tls->ssl = SSL_new(tls->ssl_ctx);
701 0 : if (tls->ssl == NULL)
702 0 : goto err_free_cert;
703 :
704 : #if OPENSSL_VERSION_NUMBER >= 0x0908060L && !defined(OPENSSL_NO_TLSEXT)
705 : /* Enable SNI. */
706 0 : SSL_set_tlsext_host_name(tls->ssl, conn->domain);
707 : #endif
708 :
709 : /* Trust server's certificate when user sets the flag explicitly.
710 : * Otherwise call the verification callback */
711 0 : if (conn->tls_trust)
712 0 : SSL_set_verify(tls->ssl, SSL_VERIFY_NONE, NULL);
713 : else
714 0 : SSL_set_verify(tls->ssl, SSL_VERIFY_PEER, _tls_verify);
715 0 : SSL_set_app_data(tls->ssl, conn);
716 : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
717 : /* Hostname verification is supported in OpenSSL 1.0.2 and newer. */
718 0 : param = SSL_get0_param(tls->ssl);
719 :
720 : /*
721 : * Allow only complete wildcards. RFC 6125 discourages wildcard usage
722 : * completely, and lists internationalized domain names as a reason
723 : * against partial wildcards.
724 : * See https://tools.ietf.org/html/rfc6125#section-7.2 for more
725 : * information.
726 : */
727 0 : X509_VERIFY_PARAM_set_hostflags(param,
728 : X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
729 0 : X509_VERIFY_PARAM_set1_host(param, conn->domain, 0);
730 : #endif
731 :
732 0 : ret = SSL_set_fd(tls->ssl, conn->sock);
733 0 : if (ret <= 0)
734 0 : goto err_free_ssl;
735 :
736 0 : _try_open_keylogfile(tls);
737 : }
738 :
739 : return tls;
740 :
741 0 : err_free_ssl:
742 0 : SSL_free(tls->ssl);
743 0 : err_free_cert:
744 0 : X509_free(tls->client_cert);
745 0 : err_free_ctx:
746 0 : SSL_CTX_free(tls->ssl_ctx);
747 0 : err:
748 0 : strophe_free(conn->ctx, tls);
749 0 : _tls_log_error(conn->ctx);
750 0 : return NULL;
751 : }
752 :
753 0 : void tls_free(tls_t *tls)
754 : {
755 0 : if (tls->keylogfile)
756 0 : fclose(tls->keylogfile);
757 0 : strophe_free(tls->ctx, tls->channel_binding_data);
758 0 : SSL_free(tls->ssl);
759 0 : X509_free(tls->client_cert);
760 0 : SSL_CTX_free(tls->ssl_ctx);
761 0 : strophe_free(tls->ctx, tls);
762 0 : }
763 :
764 0 : xmpp_tlscert_t *tls_peer_cert(xmpp_conn_t *conn)
765 : {
766 0 : if (conn && conn->tls && conn->tls->ssl) {
767 0 : X509 *cert = STROPHE_SSL_get1_peer_certificate(conn->tls->ssl);
768 0 : if (cert) {
769 0 : xmpp_tlscert_t *tlscert = _x509_to_tlscert(conn->ctx, cert);
770 0 : X509_free(cert);
771 0 : return tlscert;
772 : }
773 : }
774 : return NULL;
775 : }
776 :
777 0 : int tls_set_credentials(tls_t *tls, const char *cafilename)
778 : {
779 0 : UNUSED(tls);
780 0 : UNUSED(cafilename);
781 0 : return -1;
782 : }
783 :
784 0 : int tls_init_channel_binding(tls_t *tls,
785 : const char **binding_prefix,
786 : size_t *binding_prefix_len)
787 : {
788 0 : const char *label = NULL;
789 0 : size_t labellen = 0;
790 0 : int ssl_version = SSL_version(tls->ssl);
791 :
792 0 : switch (ssl_version) {
793 0 : case SSL3_VERSION:
794 0 : *binding_prefix = "tls-unique";
795 0 : *binding_prefix_len = strlen("tls-unique");
796 0 : tls->channel_binding_size = 36;
797 0 : break;
798 0 : case TLS1_VERSION:
799 : case TLS1_1_VERSION:
800 : case TLS1_2_VERSION:
801 0 : *binding_prefix = "tls-unique";
802 0 : *binding_prefix_len = strlen("tls-unique");
803 0 : tls->channel_binding_size = 12;
804 0 : break;
805 : #ifdef TLS1_3_VERSION
806 0 : case TLS1_3_VERSION:
807 0 : label = "EXPORTER-Channel-Binding";
808 0 : labellen = 24;
809 0 : *binding_prefix = "tls-exporter";
810 0 : *binding_prefix_len = strlen("tls-exporter");
811 0 : tls->channel_binding_size = 32;
812 0 : break;
813 : #endif
814 0 : default:
815 0 : strophe_error(tls->ctx, "tls", "Unsupported TLS/SSL Version: %s",
816 0 : SSL_get_version(tls->ssl));
817 0 : return -1;
818 : }
819 :
820 0 : strophe_free_and_null(tls->ctx, tls->channel_binding_data);
821 0 : tls->channel_binding_data =
822 0 : strophe_alloc(tls->ctx, tls->channel_binding_size);
823 0 : if (!tls->channel_binding_data)
824 : return -1;
825 :
826 0 : if (ssl_version <= TLS1_2_VERSION) {
827 0 : size_t len;
828 0 : if (SSL_session_reused(tls->ssl)) {
829 0 : len = SSL_get_peer_finished(tls->ssl, tls->channel_binding_data,
830 : tls->channel_binding_size);
831 : } else {
832 0 : len = SSL_get_finished(tls->ssl, tls->channel_binding_data,
833 : tls->channel_binding_size);
834 : }
835 0 : if (len != tls->channel_binding_size) {
836 0 : strophe_error(tls->ctx, "tls",
837 : "Got channel binding data of wrong size %zu", len);
838 0 : return -1;
839 : }
840 : } else {
841 0 : if (SSL_export_keying_material(tls->ssl, tls->channel_binding_data,
842 : tls->channel_binding_size, label,
843 : labellen, NULL, 0, 0) != 1) {
844 0 : strophe_error(tls->ctx, "tls",
845 : "Could not get channel binding data");
846 0 : return -1;
847 : }
848 : }
849 : return 0;
850 : }
851 :
852 0 : const void *tls_get_channel_binding_data(tls_t *tls, size_t *size)
853 : {
854 0 : if (!tls->channel_binding_data || !tls->channel_binding_size) {
855 0 : strophe_error(tls->ctx, "tls", "No channel binding data available");
856 : }
857 0 : *size = tls->channel_binding_size;
858 0 : return tls->channel_binding_data;
859 : }
860 :
861 0 : int tls_start(tls_t *tls)
862 : {
863 0 : int error;
864 0 : int ret;
865 0 : long x509_res;
866 :
867 : /* Since we're non-blocking, loop the connect call until it
868 : succeeds or fails */
869 0 : while (1) {
870 0 : ret = SSL_connect(tls->ssl);
871 0 : error = ret <= 0 ? SSL_get_error(tls->ssl, ret) : 0;
872 :
873 0 : if (ret == -1 && tls_is_recoverable(NULL, error)) {
874 : /* wait for something to happen on the sock before looping back */
875 0 : _tls_sock_wait(tls, error);
876 0 : continue;
877 : }
878 :
879 : /* success or fatal error */
880 0 : break;
881 : }
882 :
883 0 : x509_res = SSL_get_verify_result(tls->ssl);
884 0 : if (x509_res == X509_V_OK) {
885 0 : strophe_debug(tls->ctx, "tls", "Certificate verification passed");
886 : } else {
887 0 : strophe_debug(tls->ctx, "tls",
888 : "Certificate verification FAILED, result=%s(%ld)",
889 : TLS_ERROR_STR((int)x509_res, cert_errors), x509_res);
890 0 : if (ret > 0)
891 0 : strophe_debug(tls->ctx, "tls", "User decided to connect anyways");
892 : }
893 0 : _tls_dump_cert_info(tls);
894 :
895 0 : _tls_set_error(tls, error);
896 0 : return ret <= 0 ? 0 : 1;
897 : }
898 :
899 0 : int tls_stop(tls_t *tls)
900 : {
901 0 : int retries = 0;
902 0 : int error;
903 0 : int ret;
904 :
905 : /* According to OpenSSL.org, we must not call SSL_shutdown(3)
906 : if a previous fatal error has occurred on a connection. */
907 0 : if (tls->lasterror == SSL_ERROR_SYSCALL || tls->lasterror == SSL_ERROR_SSL)
908 : return 1;
909 :
910 0 : while (1) {
911 0 : ++retries;
912 0 : ret = SSL_shutdown(tls->ssl);
913 0 : error = ret < 0 ? SSL_get_error(tls->ssl, ret) : 0;
914 0 : if (ret == 1 || !tls_is_recoverable(NULL, error) ||
915 : retries >= TLS_SHUTDOWN_MAX_RETRIES) {
916 : break;
917 : }
918 0 : _tls_sock_wait(tls, error);
919 : }
920 0 : if (error == SSL_ERROR_SYSCALL && errno == 0) {
921 : /*
922 : * Handle special case when peer closes connection instead of
923 : * proper shutdown.
924 : */
925 0 : error = 0;
926 0 : ret = 1;
927 : }
928 0 : _tls_set_error(tls, error);
929 :
930 0 : return ret <= 0 ? 0 : 1;
931 : }
932 :
933 0 : int tls_is_recoverable(struct conn_interface *intf, int error)
934 : {
935 0 : UNUSED(intf);
936 0 : return (error == SSL_ERROR_NONE || error == SSL_ERROR_WANT_READ ||
937 0 : error == SSL_ERROR_WANT_WRITE || error == SSL_ERROR_WANT_CONNECT ||
938 : error == SSL_ERROR_WANT_ACCEPT);
939 : }
940 :
941 0 : int tls_pending(struct conn_interface *intf)
942 : {
943 0 : return SSL_pending(intf->conn->tls->ssl);
944 : }
945 :
946 0 : int tls_read(struct conn_interface *intf, void *buff, size_t len)
947 : {
948 0 : int ret;
949 0 : tls_t *tls = intf->conn->tls;
950 :
951 0 : ret = SSL_read(tls->ssl, buff, len);
952 0 : _tls_set_error(tls, ret <= 0 ? SSL_get_error(tls->ssl, ret) : 0);
953 :
954 0 : return ret;
955 : }
956 :
957 0 : int tls_write(struct conn_interface *intf, const void *buff, size_t len)
958 : {
959 0 : int ret;
960 0 : tls_t *tls = intf->conn->tls;
961 :
962 0 : ret = SSL_write(tls->ssl, buff, len);
963 0 : _tls_set_error(tls, ret <= 0 ? SSL_get_error(tls->ssl, ret) : 0);
964 :
965 0 : return ret;
966 : }
967 :
968 0 : int tls_clear_pending_write(struct conn_interface *intf)
969 : {
970 0 : UNUSED(intf);
971 0 : return 0;
972 : }
973 :
974 0 : static void _tls_sock_wait(tls_t *tls, int error)
975 : {
976 0 : struct timeval tv;
977 0 : fd_set rfds;
978 0 : fd_set wfds;
979 0 : int nfds;
980 0 : int ret;
981 :
982 0 : if (error == SSL_ERROR_NONE)
983 0 : return;
984 :
985 0 : FD_ZERO(&rfds);
986 0 : FD_ZERO(&wfds);
987 0 : if (error == SSL_ERROR_WANT_READ)
988 0 : FD_SET(tls->sock, &rfds);
989 0 : if (error == SSL_ERROR_WANT_WRITE)
990 0 : FD_SET(tls->sock, &wfds);
991 0 : nfds = (error == SSL_ERROR_WANT_READ || error == SSL_ERROR_WANT_WRITE)
992 0 : ? tls->sock + 1
993 0 : : 0;
994 0 : do {
995 0 : tv.tv_sec = TLS_TIMEOUT_SEC;
996 0 : tv.tv_usec = TLS_TIMEOUT_USEC;
997 0 : ret = select(nfds, &rfds, &wfds, NULL, &tv);
998 0 : } while (ret == -1 && errno == EINTR);
999 : }
1000 :
1001 0 : static const char *_tls_error_str(int error, const char **tbl, size_t tbl_size)
1002 : {
1003 0 : return (error >= 0 && (size_t)error < tbl_size) ? tbl[error] : "UNKNOWN";
1004 : }
1005 :
1006 0 : static void _tls_set_error(tls_t *tls, int error)
1007 : {
1008 0 : if (error != 0 && !tls_is_recoverable(NULL, error)) {
1009 0 : strophe_debug(tls->ctx, "tls", "error=%s(%d) errno=%d lasterror=%d",
1010 0 : TLS_ERROR_STR(error, tls_errors), error, errno,
1011 : tls->lasterror);
1012 0 : _tls_log_error(tls->ctx);
1013 0 : } else if (tls->lasterror && tls->lasterror != error) {
1014 0 : strophe_debug_verbose(1, tls->ctx, "tls", "overwrite lasterror=%d",
1015 : tls->lasterror);
1016 : }
1017 0 : tls->lasterror = error;
1018 0 : }
1019 :
1020 0 : static void _tls_log_error(xmpp_ctx_t *ctx)
1021 : {
1022 0 : unsigned long e;
1023 :
1024 0 : do {
1025 0 : e = ERR_get_error();
1026 0 : if (e != 0) {
1027 0 : strophe_debug(
1028 : ctx, "tls", "error:%08X:%s:%s:%s", e, ERR_lib_error_string(e),
1029 : STROPHE_ERR_func_error_string(e), ERR_reason_error_string(e));
1030 : }
1031 0 : } while (e != 0);
1032 0 : }
1033 :
1034 0 : static void _tls_dump_cert_info(tls_t *tls)
1035 : {
1036 0 : X509 *cert;
1037 0 : char *name;
1038 :
1039 0 : cert = STROPHE_SSL_get1_peer_certificate(tls->ssl);
1040 0 : if (cert == NULL)
1041 0 : strophe_debug(tls->ctx, "tls", "Certificate was not presented by peer");
1042 : else {
1043 0 : name = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0);
1044 0 : if (name != NULL) {
1045 0 : strophe_debug(tls->ctx, "tls", "Subject=%s", name);
1046 0 : OPENSSL_free(name);
1047 : }
1048 0 : name = X509_NAME_oneline(X509_get_issuer_name(cert), NULL, 0);
1049 0 : if (name != NULL) {
1050 0 : strophe_debug(tls->ctx, "tls", "Issuer=%s", name);
1051 0 : OPENSSL_free(name);
1052 : }
1053 0 : X509_free(cert);
1054 : }
1055 0 : }
1056 :
1057 8 : static X509 *_tls_cert_read_x509(xmpp_conn_t *conn)
1058 : {
1059 8 : if (conn->tls && conn->tls->client_cert)
1060 : return conn->tls->client_cert;
1061 8 : BIO *f = BIO_new_file(conn->tls_client_cert, "r");
1062 8 : if (!f) {
1063 0 : strophe_debug(conn->ctx, "tls", "f == NULL");
1064 0 : return NULL;
1065 : }
1066 8 : X509 *c = PEM_read_bio_X509(f, NULL, NULL, NULL);
1067 8 : BIO_free(f);
1068 8 : if (!c) {
1069 0 : _tls_log_error(conn->ctx);
1070 : }
1071 : return c;
1072 : }
1073 :
1074 32 : static int _tls_parse_p12(PKCS12 *p12,
1075 : const char *pass,
1076 : EVP_PKEY **pkey,
1077 : X509 **cert,
1078 : STACK_OF(X509) * *ca)
1079 : {
1080 : /* For some reason `PKCS12_parse()` fails without a `EVP_PKEY`
1081 : * so if the user doesn't want it, use a local one and free it
1082 : * again directly after parsing.
1083 : */
1084 32 : EVP_PKEY *pkey_;
1085 32 : if (!pkey)
1086 32 : pkey = &pkey_;
1087 32 : int parse_ok = PKCS12_parse(p12, pass, pkey, cert, ca);
1088 32 : if (pkey == &pkey_ && pkey_)
1089 24 : EVP_PKEY_free(pkey_);
1090 32 : return parse_ok;
1091 : }
1092 :
1093 : static X509 *
1094 24 : _tls_cert_read_p12(xmpp_conn_t *conn, EVP_PKEY **pkey, STACK_OF(X509) * *ca)
1095 : {
1096 24 : if (conn->tls && conn->tls->client_cert && !pkey && !ca)
1097 24 : return conn->tls->client_cert;
1098 24 : X509 *cert = NULL;
1099 24 : PKCS12 *p12 = NULL;
1100 24 : BIO *f = BIO_new_file(conn->tls_client_cert, "rb");
1101 24 : if (!f) {
1102 0 : strophe_debug(conn->ctx, "tls", "f == NULL");
1103 0 : goto error_out;
1104 : }
1105 24 : p12 = d2i_PKCS12_bio(f, NULL);
1106 24 : BIO_free(f);
1107 24 : if (!p12) {
1108 0 : strophe_debug(conn->ctx, "tls", "Could not read p12 file");
1109 0 : goto error_out;
1110 : }
1111 :
1112 : /* First try to open file w/o a pass */
1113 24 : if (_tls_parse_p12(p12, NULL, pkey, &cert, ca)) {
1114 16 : goto success;
1115 : }
1116 8 : cert = NULL;
1117 :
1118 8 : unsigned int retries = 0;
1119 :
1120 8 : pem_password_cb *cb = PEM_def_callback;
1121 8 : void *userdata = NULL;
1122 8 : if (conn->password_callback) {
1123 8 : cb = _tls_password_callback;
1124 8 : userdata = conn;
1125 : }
1126 :
1127 8 : while (retries++ < conn->password_retries) {
1128 8 : char pass[PEM_BUFSIZE + 1];
1129 8 : int passlen = cb(pass, PEM_BUFSIZE, 0, userdata);
1130 8 : if (passlen < 0 || passlen > PEM_BUFSIZE)
1131 0 : goto error_out;
1132 8 : int parse_ok = _tls_parse_p12(p12, pass, pkey, &cert, ca);
1133 8 : if (parse_ok) {
1134 8 : goto success;
1135 : }
1136 0 : cert = NULL;
1137 0 : tls_clear_password_cache(conn);
1138 0 : int err = ERR_peek_last_error();
1139 0 : if (ERR_GET_LIB(err) == ERR_LIB_PKCS12 &&
1140 0 : ERR_GET_REASON(err) == PKCS12_R_MAC_VERIFY_FAILURE) {
1141 0 : strophe_debug(conn->ctx, "tls",
1142 : "Entered password is most likely wrong!");
1143 0 : continue;
1144 : }
1145 0 : strophe_debug(conn->ctx, "tls", "Could not parse PKCS#12");
1146 0 : goto error_out;
1147 : }
1148 0 : error_out:
1149 0 : _tls_log_error(conn->ctx);
1150 24 : success:
1151 24 : if (p12)
1152 24 : PKCS12_free(p12);
1153 24 : return cert;
1154 : }
1155 :
1156 32 : static X509 *_tls_cert_read(xmpp_conn_t *conn)
1157 : {
1158 32 : if (conn->tls && conn->tls->client_cert)
1159 : return conn->tls->client_cert;
1160 32 : if (conn->tls_client_cert && !conn->tls_client_key) {
1161 24 : return _tls_cert_read_p12(conn, NULL, NULL);
1162 : }
1163 8 : return _tls_cert_read_x509(conn);
1164 : }
1165 :
1166 58 : static int _tls_xaddr_nid(void)
1167 : {
1168 58 : static int xaddr_nid = NID_undef;
1169 58 : if (xaddr_nid == NID_undef) {
1170 2 : xaddr_nid = OBJ_sn2nid("id-on-xmppAddr");
1171 : }
1172 58 : if (xaddr_nid == NID_undef) {
1173 0 : xaddr_nid = OBJ_create("1.3.6.1.5.5.7.8.5", "id-on-xmppAddr",
1174 : "XmppAddr Identifier");
1175 : }
1176 58 : return xaddr_nid;
1177 : }
1178 :
1179 32 : static GENERAL_NAMES *_tls_conn_get_names(xmpp_conn_t *conn)
1180 : {
1181 32 : X509 *client_cert;
1182 32 : GENERAL_NAMES *names = NULL;
1183 32 : client_cert = _tls_cert_read(conn);
1184 32 : if (!client_cert)
1185 : return NULL;
1186 32 : names = _tls_cert_get_names(client_cert);
1187 32 : if (!conn->tls || !conn->tls->client_cert)
1188 32 : X509_free(client_cert);
1189 : return names;
1190 : }
1191 :
1192 32 : static GENERAL_NAMES *_tls_cert_get_names(X509 *client_cert)
1193 : {
1194 32 : int san = X509_get_ext_by_NID(client_cert, NID_subject_alt_name, 0);
1195 32 : X509_EXTENSION *san_ext = X509_get_ext(client_cert, san);
1196 32 : if (!san_ext)
1197 32 : return NULL;
1198 32 : ASN1_OCTET_STRING *data = X509_EXTENSION_get_data(san_ext);
1199 32 : if (!data)
1200 : return NULL;
1201 32 : const unsigned char *d = ASN1_STRING_get0_data(data);
1202 32 : if (!d)
1203 : return NULL;
1204 32 : return d2i_GENERAL_NAMES(NULL, &d, ASN1_STRING_length(data));
1205 : }
1206 :
1207 : /** Convert GENERAL_NAME* to a string
1208 : *
1209 : * This checks whether the GENERAL_NAME* that is given has the
1210 : * correct id-on-xmppAddr set and then optionally converts this
1211 : * form ASN.1 to a string/char*.
1212 : *
1213 : * When `res` pointer is set to NULL this method doesn't allocate
1214 : * the result but only checks whether it is in the correct format.
1215 : *
1216 : * @param name Pointer to the GENERAL_NAME that shall be converted
1217 : * @param res Result-pointer (optional, can be NULL)
1218 : *
1219 : * @return classic Unix style - 0=success, 1=error
1220 : */
1221 104 : static int _tls_xmppaddr_to_string(GENERAL_NAME *name, char **res)
1222 : {
1223 104 : ASN1_OBJECT *oid;
1224 104 : ASN1_TYPE *val;
1225 104 : if (!name || name->type != GEN_OTHERNAME)
1226 104 : return 1;
1227 56 : if (GENERAL_NAME_get0_otherName(name, &oid, &val) == 0)
1228 : return 1;
1229 56 : if (OBJ_obj2nid(oid) != _tls_xaddr_nid() || !val)
1230 : return 1;
1231 56 : if (!res)
1232 : return 0;
1233 40 : if (ASN1_STRING_to_UTF8((unsigned char **)res, val->value.asn1_string) < 0)
1234 : return 1;
1235 : return 0;
1236 : }
1237 :
1238 0 : static int _tls_dnsname_to_string(GENERAL_NAME *name, char **res)
1239 : {
1240 0 : ASN1_STRING *str;
1241 0 : if (!name || name->type != GEN_DNS)
1242 : return 1;
1243 0 : str = GENERAL_NAME_get0_value(name, NULL);
1244 0 : if (str == NULL)
1245 : return 1;
1246 0 : if (!res)
1247 : return 0;
1248 0 : if (ASN1_STRING_to_UTF8((unsigned char **)res, str) < 0)
1249 : return 1;
1250 : return 0;
1251 : }
|